#!/usr/bin/python
# -*- coding:utf-8 -*-
"""
正则表达式练习
"""
import re

"""
m = re.search(pattern, string)  # 搜索整个字符串,直到发现符合的子字符串.
m = re.match(pattern, string)   # 从头开始检查字符串是否符合正则表达式.必须从字符串的第一个字符开始就相符.
str = re.sub(pattern, replacement, string) # 在string中利用正则变换pattern进行搜索,对于搜索到的字符串,用另一字符串replacement替换.返回替换后的字符串.
re.split()    # 根据正则表达式分割字符串, 将分割后的所有子字符串放在一个表(list)中返回
re.findall()  # 根据正则表达式搜索字符串,将所有符合的子字符串放在一个表(list)中返回
"""

"""
单个字符
.          任意的一个字符
a|b        字符a或字符b
[afg]      a或者f或者g的一个字符
[0-4]      0-4范围内的一个字符
[a-f]      a-f范围内的一个字符
[^m]       不是m的一个字符
\s         一个空格
\S         一个非空格
\d         [0-9]
\D         [^0-9]
\w         [0-9a-zA-Z]
\W         [^0-9a-zA-Z]
"""
"""
重复
*         重复 >=0 次
+         重复 >=1 次
?         重复 0或者1 次
{m}       重复m次.比如说 a{4}相当于aaaa,再比如说[1-3]{2}相当于[1-3][1-3]
{m, n}    重复m到n次.比如说a{2, 5}表示a重复2到5次.小于m次的重复,或者大于n次的重复都不符合条件.
"""
"""
位置
^ 字符串的起始位置
$ 字符串的结尾位置
"""

"""
这个方法将会从string（我们要匹配的字符串）的开头开始,尝试匹配pattern,一直向后匹配,如果遇到无法匹配的字符,立即返回None,如果匹配未结束已经到达string的末尾,也会返回None.
两个结果均表示匹配失败,否则匹配pattern成功,同时匹配终止,不再对string向后匹配.
"""


def match_test():
    # 将正则表达式编译成Pattern对象,注意hello前面的r的意思是“原生字符串”
    pattern = re.compile(r'hello')

    # 使用re.match匹配文本,获得匹配结果,无法匹配时将返回None
    result1 = re.match(pattern, 'hello')
    result2 = re.match(pattern, 'helloo CQC!hello')
    result3 = re.match(pattern, 'helo CQC!')
    result4 = re.match(pattern, 'hello CQC!')

    # 如果1匹配成功
    if result1:
        # 使用Match获得分组信息
        print result1.group()
    else:
        print '1匹配失败！'

    # 如果2匹配成功
    if result2:
        # 使用Match获得分组信息
        print result2.group()
    else:
        print '2匹配失败！'

    # 如果3匹配成功
    if result3:
        # 使用Match获得分组信息
        print result3.group()
    else:
        print '3匹配失败！'

    # 如果4匹配成功
    if result4:
        # 使用Match获得分组信息
        print result4.group()
    else:
        print '4匹配失败！'
    print "---------------"

    """
    属性：
    1.string: 匹配时使用的文本.
    2.re: 匹配时使用的Pattern对象.
    3.pos: 文本中正则表达式开始搜索的索引.值与Pattern.match()和Pattern.seach()方法的同名参数相同.
    4.endpos: 文本中正则表达式结束搜索的索引.值与Pattern.match()和Pattern.seach()方法的同名参数相同.
    5.lastindex: 最后一个被捕获的分组在文本中的索引.如果没有被捕获的分组,将为None.
    6.lastgroup: 最后一个被捕获的分组的别名.如果这个分组没有别名或者没有被捕获的分组,将为None.
    方法：
    1.group([group1, …]):
    获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回.group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时,返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串.
    2.groups([default]):
    以元组形式返回全部分组截获的字符串.相当于调用group(1,2,…last).default表示没有截获字符串的组以这个值替代,默认为None.
    3.groupdict([default]):
    返回以有别名的组的别名为键、以该组截获的子串为值的字典,没有别名的组不包含在内.default含义同上.
    4.start([group]):
    返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）.group默认值为0.
    5.end([group]):
    返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）.group默认值为0.
    6.span([group]):
    返回(start(group), end(group)).
    7.expand(template):
    将匹配到的分组代入template中然后返回.template中可以使用\id或\g、\g引用分组,但不能使用编号0.\id与\g是等价的；但\10将被认为是第10个分组,如果你想表达\1之后是字符’0’,只能使用\g0.
    """
    # 匹配如下内容：单词+空格+单词+任意字符
    m = re.match(r'(\w+)(\w+)(?P<sign>.*)', 'hello world!')

    print "m.string:", m.string
    print "m.re:", m.re
    print "m.pos:", m.pos
    print "m.endpos:", m.endpos
    print "m.lastindex:", m.lastindex
    print "m.lastgroup:", m.lastgroup
    print "m.group():", m.group()
    print "m.group(1,2):", m.group(1, 2)
    print "m.groups():", m.groups()
    print "m.groupdict():", m.groupdict()
    print "m.start(2):", m.start(2)
    print "m.end(2):", m.end(2)
    print "m.span(2):", m.span(2)
    print r"m.expand(r'\g \g\g'):", m.expand(r'\2 \1\3')


def search_test():
    """
    search方法与match方法极其类似,区别在于match()函数只检测re是不是在string的开始位置匹配,search()会扫描整个string查找匹配,
    match（）只有在0位置匹配成功的话才有返回,如果不是开始位置匹配成功的话,match()就返回None.同样,search方法的返回对象同样match()返回对象的方法和属性.
    :return:
    """
    # 将正则表达式编译成Pattern对象
    pattern = re.compile(r'world')
    # 使用search()查找匹配的子串,不存在能匹配的子串时将返回None
    # 这个例子中使用match()无法成功匹配
    match = re.search(pattern, 'hello world! this is a world')
    if match:
        # 使用Match获得分组信息
        print match.group()
        print match.end()


def split_test():
    """
    按照能够匹配的子串将string分割后返回列表.maxsplit用于指定最大分割次数,不指定将全部分割.
    :return:
    """
    pattern = re.compile(r'\d+')
    print re.split(pattern, 'one1two2three3four42five')


def findall_test():
    """
    搜索string,以列表形式返回全部能匹配的子串.
    :return:
    """
    pattern = re.compile(r'\d+?')
    print re.findall(pattern, 'one1two2three3four42')


def finditer_test():
    """
    搜索string,返回一个顺序访问每一个匹配结果（Match对象）的迭代器.
    :return:
    """
    pattern = re.compile(r'\d+')
    for m in re.finditer(pattern, 'one1two2three3four4'):
        print m.group()


"""
使用repl替换string中每一个匹配的子串后返回替换后的字符串.
当repl是一个字符串时,可以使用\id或\g、\g引用分组,但不能使用编号0.
当repl是一个方法时,这个方法应当只接受一个参数（Match对象）,并返回一个字符串用于替换（返回的字符串中不能再引用分组）.
count用于指定最多替换次数,不指定时全部替换.
"""


def sub_test():
    pattern = re.compile(r'(\w+) (\w+)')
    s = 'i say, hello world!'
    print re.sub(pattern, r'\2 \1', s)

    def func(m):
        return ' '.join([m.group(1).title(), m.group(2).title()])

    print re.sub(pattern, func, s)


def subn_test():
    """
    返回 (sub(repl, string[, count]), 替换次数).
    :return:
    """
    p = re.compile(r'(\w+) (\w+)')
    s = 'i say, hello world!'

    print p.subn(r'\2 \1', s)

    def func(m):
        return m.group(1).title() + ' ' + m.group(2).title()

    print p.subn(func, s)


def num_test():
    """
    从字符串中截取编号测试
    :return:
    """
    pattern = re.compile(r'\[([\w\-]+)\]', flags=re.I)
    s = '[MJ9-1-2]字符串中,[ab2-1-1]截取编号,[ms3-3-1]测试，[MS3-3-1]实例,[ms3-3-0]测试,[3-3-1]实例'

    print re.findall(pattern, s)


if __name__ == "__main__":
    # match_test()
    # search_test()
    # split_test()
    # findall_test()
    # finditer_test()
    # sub_test()
    num_test()
